[][src]Trait protocol::Unravel

pub trait Unravel<C: ?Sized> {
    type Finalize: Future<C, Ok = (), Error = <Self::Target as Future<C>>::Error>;
    type Target: Future<C, Ok = Self::Finalize>;
    fn unravel(self) -> Self::Target;
}

Associated Types

type Finalize: Future<C, Ok = (), Error = <Self::Target as Future<C>>::Error>

type Target: Future<C, Ok = Self::Finalize>

Loading content...

Required methods

fn unravel(self) -> Self::Target

Loading content...

Implementations on Foreign Types

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 2]> + Fork<T> + Unpin> Unravel<C> for [T; 2] where
    T: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin,
    C::Future: Unpin
[src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 2]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0002Unravel<T, C>

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 3]> + Fork<T> + Unpin> Unravel<C> for [T; 3] where
    T: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin,
    C::Future: Unpin
[src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 3]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0003Unravel<T, C>

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 4]> + Fork<T> + Unpin> Unravel<C> for [T; 4] where
    T: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin,
    C::Future: Unpin
[src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 4]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0004Unravel<T, C>

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 5]> + Fork<T> + Unpin> Unravel<C> for [T; 5] where
    T: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin,
    C::Future: Unpin
[src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 5]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0005Unravel<T, C>

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 6]> + Fork<T> + Unpin> Unravel<C> for [T; 6] where
    T: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin,
    C::Future: Unpin
[src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 6]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0006Unravel<T, C>

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 7]> + Fork<T> + Unpin> Unravel<C> for [T; 7] where
    T: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin,
    C::Future: Unpin
[src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 7]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0007Unravel<T, C>

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 8]> + Fork<T> + Unpin> Unravel<C> for [T; 8] where
    T: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin,
    C::Future: Unpin
[src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 8]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0008Unravel<T, C>

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 9]> + Fork<T> + Unpin> Unravel<C> for [T; 9] where
    T: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin,
    C::Future: Unpin
[src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 9]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0009Unravel<T, C>

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 10]> + Fork<T> + Unpin> Unravel<C> for [T; 10] where
    T: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin,
    C::Future: Unpin
[src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 10]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0010Unravel<T, C>

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 11]> + Fork<T> + Unpin> Unravel<C> for [T; 11] where
    T: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin,
    C::Future: Unpin
[src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 11]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0011Unravel<T, C>

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 12]> + Fork<T> + Unpin> Unravel<C> for [T; 12] where
    T: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin,
    C::Future: Unpin
[src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 12]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0012Unravel<T, C>

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 13]> + Fork<T> + Unpin> Unravel<C> for [T; 13] where
    T: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin,
    C::Future: Unpin
[src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 13]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0013Unravel<T, C>

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 14]> + Fork<T> + Unpin> Unravel<C> for [T; 14] where
    T: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin,
    C::Future: Unpin
[src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 14]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0014Unravel<T, C>

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 15]> + Fork<T> + Unpin> Unravel<C> for [T; 15] where
    T: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin,
    C::Future: Unpin
[src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 15]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0015Unravel<T, C>

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 16]> + Fork<T> + Unpin> Unravel<C> for [T; 16] where
    T: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin,
    C::Future: Unpin
[src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 16]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0016Unravel<T, C>

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 17]> + Fork<T> + Unpin> Unravel<C> for [T; 17] where
    T: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin,
    C::Future: Unpin
[src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 17]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0017Unravel<T, C>

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 18]> + Fork<T> + Unpin> Unravel<C> for [T; 18] where
    T: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin,
    C::Future: Unpin
[src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 18]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0018Unravel<T, C>

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 19]> + Fork<T> + Unpin> Unravel<C> for [T; 19] where
    T: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin,
    C::Future: Unpin
[src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 19]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0019Unravel<T, C>

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 20]> + Fork<T> + Unpin> Unravel<C> for [T; 20] where
    T: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin,
    C::Future: Unpin
[src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 20]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0020Unravel<T, C>

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 21]> + Fork<T> + Unpin> Unravel<C> for [T; 21] where
    T: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin,
    C::Future: Unpin
[src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 21]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0021Unravel<T, C>

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 22]> + Fork<T> + Unpin> Unravel<C> for [T; 22] where
    T: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin,
    C::Future: Unpin
[src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 22]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0022Unravel<T, C>

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 23]> + Fork<T> + Unpin> Unravel<C> for [T; 23] where
    T: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin,
    C::Future: Unpin
[src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 23]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0023Unravel<T, C>

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 24]> + Fork<T> + Unpin> Unravel<C> for [T; 24] where
    T: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin,
    C::Future: Unpin
[src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 24]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0024Unravel<T, C>

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 25]> + Fork<T> + Unpin> Unravel<C> for [T; 25] where
    T: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin,
    C::Future: Unpin
[src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 25]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0025Unravel<T, C>

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 26]> + Fork<T> + Unpin> Unravel<C> for [T; 26] where
    T: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin,
    C::Future: Unpin
[src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 26]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0026Unravel<T, C>

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 27]> + Fork<T> + Unpin> Unravel<C> for [T; 27] where
    T: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin,
    C::Future: Unpin
[src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 27]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0027Unravel<T, C>

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 28]> + Fork<T> + Unpin> Unravel<C> for [T; 28] where
    T: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin,
    C::Future: Unpin
[src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 28]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0028Unravel<T, C>

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 29]> + Fork<T> + Unpin> Unravel<C> for [T; 29] where
    T: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin,
    C::Future: Unpin
[src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 29]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0029Unravel<T, C>

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 30]> + Fork<T> + Unpin> Unravel<C> for [T; 30] where
    T: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin,
    C::Future: Unpin
[src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 30]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0030Unravel<T, C>

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 31]> + Fork<T> + Unpin> Unravel<C> for [T; 31] where
    T: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin,
    C::Future: Unpin
[src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 31]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0031Unravel<T, C>

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 32]> + Fork<T> + Unpin> Unravel<C> for [T; 32] where
    T: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin,
    C::Future: Unpin
[src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 32]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0032Unravel<T, C>

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 64]> + Fork<T> + Unpin> Unravel<C> for [T; 64] where
    T: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin,
    C::Future: Unpin
[src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 64]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0064Unravel<T, C>

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 128]> + Fork<T> + Unpin> Unravel<C> for [T; 128] where
    T: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin,
    C::Future: Unpin
[src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 128]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0128Unravel<T, C>

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 256]> + Fork<T> + Unpin> Unravel<C> for [T; 256] where
    T: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin,
    C::Future: Unpin
[src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 256]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0256Unravel<T, C>

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 512]> + Fork<T> + Unpin> Unravel<C> for [T; 512] where
    T: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin,
    C::Future: Unpin
[src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 512]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0512Unravel<T, C>

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 1024]> + Fork<T> + Unpin> Unravel<C> for [T; 1024] where
    T: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin,
    C::Future: Unpin
[src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 1024]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array1024Unravel<T, C>

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 2048]> + Fork<T> + Unpin> Unravel<C> for [T; 2048] where
    T: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin,
    C::Future: Unpin
[src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 2048]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array2048Unravel<T, C>

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 4096]> + Fork<T> + Unpin> Unravel<C> for [T; 4096] where
    T: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin,
    C::Future: Unpin
[src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 4096]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array4096Unravel<T, C>

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 8192]> + Fork<T> + Unpin> Unravel<C> for [T; 8192] where
    T: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin,
    C::Future: Unpin
[src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 8192]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array8192Unravel<T, C>

impl<T: Unpin, C: ?Sized + Write<<C as Dispatch<T>>::Handle> + Fork<T> + Unpin> Unravel<C> for [T; 1] where
    C::Future: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin
[src]

type Finalize = MapErr<C::Finalize, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0001Unravel<T, C>

impl<T: Unpin, C: ?Sized + Write<Option<<C as Dispatch<T>>::Handle>> + Fork<T> + Unpin> Unravel<C> for Option<T> where
    C::Future: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin
[src]

type Finalize = Either<MapErr<C::Finalize, fn(_: <C::Finalize as Future<C>>::Error) -> OptionUnravelError<<C as Write<Option<<C as Dispatch<T>>::Handle>>>::Error, <<C as Fork<T>>::Future as Future<C>>::Error, <<C as Fork<T>>::Target as Future<C>>::Error, <<C as Fork<T>>::Finalize as Future<C>>::Error>>, Ready<(), OptionUnravelError<<C as Write<Option<<C as Dispatch<T>>::Handle>>>::Error, <<C as Fork<T>>::Future as Future<C>>::Error, <<C as Fork<T>>::Target as Future<C>>::Error, <<C as Fork<T>>::Finalize as Future<C>>::Error>>>

type Target = OptionUnravel<T, C>

impl<C: ?Sized + Unpin + Write<Self>> Unravel<C> for u8[src]

type Finalize = Ready<(), C::Error>

type Target = PrimitiveUnravel<Self>

impl<C: ?Sized + Unpin + Write<Self>> Unravel<C> for u16[src]

type Finalize = Ready<(), C::Error>

type Target = PrimitiveUnravel<Self>

impl<C: ?Sized + Unpin + Write<Self>> Unravel<C> for u32[src]

type Finalize = Ready<(), C::Error>

type Target = PrimitiveUnravel<Self>

impl<C: ?Sized + Unpin + Write<Self>> Unravel<C> for u64[src]

type Finalize = Ready<(), C::Error>

type Target = PrimitiveUnravel<Self>

impl<C: ?Sized + Unpin + Write<Self>> Unravel<C> for u128[src]

type Finalize = Ready<(), C::Error>

type Target = PrimitiveUnravel<Self>

impl<C: ?Sized + Unpin + Write<Self>> Unravel<C> for i8[src]

type Finalize = Ready<(), C::Error>

type Target = PrimitiveUnravel<Self>

impl<C: ?Sized + Unpin + Write<Self>> Unravel<C> for i16[src]

type Finalize = Ready<(), C::Error>

type Target = PrimitiveUnravel<Self>

impl<C: ?Sized + Unpin + Write<Self>> Unravel<C> for i32[src]

type Finalize = Ready<(), C::Error>

type Target = PrimitiveUnravel<Self>

impl<C: ?Sized + Unpin + Write<Self>> Unravel<C> for i64[src]

type Finalize = Ready<(), C::Error>

type Target = PrimitiveUnravel<Self>

impl<C: ?Sized + Unpin + Write<Self>> Unravel<C> for i128[src]

type Finalize = Ready<(), C::Error>

type Target = PrimitiveUnravel<Self>

impl<C: ?Sized + Unpin + Write<Self>> Unravel<C> for f32[src]

type Finalize = Ready<(), C::Error>

type Target = PrimitiveUnravel<Self>

impl<C: ?Sized + Unpin + Write<Self>> Unravel<C> for f64[src]

type Finalize = Ready<(), C::Error>

type Target = PrimitiveUnravel<Self>

impl<C: ?Sized + Unpin + Write<Self>> Unravel<C> for bool[src]

type Finalize = Ready<(), C::Error>

type Target = PrimitiveUnravel<Self>

impl<C: ?Sized + Unpin + Write<Self>> Unravel<C> for char[src]

type Finalize = Ready<(), C::Error>

type Target = PrimitiveUnravel<Self>

impl<C: ?Sized + Unpin + Write<Self>> Unravel<C> for usize[src]

type Finalize = Ready<(), C::Error>

type Target = PrimitiveUnravel<Self>

impl<C: ?Sized + Unpin + Write<Self>> Unravel<C> for isize[src]

type Finalize = Ready<(), C::Error>

type Target = PrimitiveUnravel<Self>

impl<C: ?Sized + Unpin + Write<Self>> Unravel<C> for String[src]

type Finalize = Ready<(), C::Error>

type Target = PrimitiveUnravel<Self>

impl<C: ?Sized> Unravel<C> for ()[src]

type Finalize = Ready<()>

type Target = Ready<Ready<()>>

impl<T: Unpin + ?Sized, C: ?Sized> Unravel<C> for PhantomData<T>[src]

type Finalize = Ready<()>

type Target = Ready<Ready<()>>

impl<T: Unpin, C: ?Sized> Unravel<C> for [T; 0][src]

type Finalize = Ready<()>

type Target = Ready<Ready<()>>

impl<T: Unpin, E: Unpin, C: ?Sized + Write<Result<<C as Dispatch<T>>::Handle, <C as Dispatch<E>>::Handle>> + Fork<T> + Fork<E> + Unpin> Unravel<C> for Result<T, E> where
    <C as Fork<T>>::Future: Unpin,
    <C as Fork<E>>::Future: Unpin,
    <C as Fork<T>>::Target: Unpin,
    <C as Fork<E>>::Target: Unpin,
    <C as Fork<T>>::Finalize: Unpin,
    <C as Fork<E>>::Finalize: Unpin,
    <C as Dispatch<T>>::Handle: Unpin,
    <C as Dispatch<E>>::Handle: Unpin
[src]

type Finalize = Either<MapErr<<C as Fork<T>>::Finalize, fn(_: <<C as Fork<T>>::Finalize as Future<C>>::Error) -> ResultUnravelError<<<C as Fork<T>>::Future as Future<C>>::Error, <<C as Fork<E>>::Future as Future<C>>::Error, <C as Write<Result<<C as Dispatch<T>>::Handle, <C as Dispatch<E>>::Handle>>>::Error, <<C as Fork<T>>::Target as Future<C>>::Error, <<C as Fork<E>>::Target as Future<C>>::Error, <<C as Fork<T>>::Finalize as Future<C>>::Error, <<C as Fork<E>>::Finalize as Future<C>>::Error>>, MapErr<<C as Fork<E>>::Finalize, fn(_: <<C as Fork<E>>::Finalize as Future<C>>::Error) -> ResultUnravelError<<<C as Fork<T>>::Future as Future<C>>::Error, <<C as Fork<E>>::Future as Future<C>>::Error, <C as Write<Result<<C as Dispatch<T>>::Handle, <C as Dispatch<E>>::Handle>>>::Error, <<C as Fork<T>>::Target as Future<C>>::Error, <<C as Fork<E>>::Target as Future<C>>::Error, <<C as Fork<T>>::Finalize as Future<C>>::Error, <<C as Fork<E>>::Finalize as Future<C>>::Error>>>

type Target = ResultUnravel<T, E, C>

impl<T: Unpin, U: Unpin, C: ?Sized + Write<(<C as Dispatch<T>>::Handle, <C as Dispatch<U>>::Handle)> + Fork<T> + Fork<U> + Unpin> Unravel<C> for (T, U) where
    <C as Fork<T>>::Future: Unpin,
    <C as Fork<U>>::Future: Unpin,
    <C as Fork<T>>::Target: Unpin,
    <C as Fork<U>>::Target: Unpin,
    <C as Fork<T>>::Finalize: Unpin,
    <C as Fork<U>>::Finalize: Unpin,
    <C as Dispatch<T>>::Handle: Unpin,
    <C as Dispatch<U>>::Handle: Unpin
[src]

type Finalize = MapErr<TupleFinalizeInner<(Option<<C as Fork<T>>::Finalize>, Option<<C as Fork<U>>::Finalize>), (T, U)>, fn(_: <TupleFinalizeInner<(Option<<C as Fork<T>>::Finalize>, Option<<C as Fork<U>>::Finalize>), (T, U)> as Future<C>>::Error) -> Tuple2UnravelError<<C as Write<(<C as Dispatch<T>>::Handle, <C as Dispatch<U>>::Handle)>>::Error, <<C as Fork<T>>::Future as Future<C>>::Error, <<C as Fork<U>>::Future as Future<C>>::Error, <Finalize<C, (T, U)> as Future<C>>::Error, <TupleFinalizeInner<(Option<<C as Fork<T>>::Finalize>, Option<<C as Fork<U>>::Finalize>), (T, U)> as Future<C>>::Error>>

type Target = Tuple2Unravel<T, U, C>

impl<T, C: ?Sized + Write<<C as Dispatch<T>>::Handle> + Fork<T> + Unpin> Unravel<C> for (T,) where
    C::Future: Unpin,
    C::Target: Unpin,
    C::Finalize: Unpin,
    C::Handle: Unpin
[src]

type Finalize = MapErr<C::Finalize, fn(_: <C::Finalize as Future<C>>::Error) -> FlatUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error>>

type Target = FlatUnravel<T, C>

impl<T0: Unpin, T1: Unpin, T2: Unpin, C: ?Sized + Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle)> + Fork<T0> + Fork<T2> + Fork<T1> + Unpin> Unravel<C> for (T0, T1, T2) where
    <C as Fork<T0>>::Future: Unpin,
    <C as Fork<T0>>::Target: Unpin,
    <C as Fork<T0>>::Finalize: Unpin,
    <C as Dispatch<T0>>::Handle: Unpin,
    <C as Fork<T2>>::Future: Unpin,
    <C as Fork<T2>>::Target: Unpin,
    <C as Fork<T2>>::Finalize: Unpin,
    <C as Dispatch<T2>>::Handle: Unpin,
    <C as Fork<T1>>::Future: Unpin,
    <C as Fork<T1>>::Finalize: Unpin,
    <C as Fork<T1>>::Target: Unpin,
    <C as Dispatch<T1>>::Handle: Unpin
[src]

type Finalize = MapErr<TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>), (T0, T1, T2)>, fn(_: <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>), (T0, T1, T2)> as Future<C>>::Error) -> Tuple3UnravelError<<C as Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle)>>::Error, <<C as Fork<T0>>::Future as Future<C>>::Error, <<C as Fork<T1>>::Future as Future<C>>::Error, <<C as Fork<T2>>::Future as Future<C>>::Error, <Finalize<C, (T0, T1, T2)> as Future<C>>::Error, <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>), (T0, T1, T2)> as Future<C>>::Error>>

type Target = Tuple3Unravel<T0, T1, T2, C>

impl<T0: Unpin, T1: Unpin, T2: Unpin, T3: Unpin, C: ?Sized + Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle)> + Fork<T0> + Fork<T3> + Fork<T1> + Fork<T2> + Unpin> Unravel<C> for (T0, T1, T2, T3) where
    <C as Fork<T0>>::Future: Unpin,
    <C as Fork<T0>>::Target: Unpin,
    <C as Fork<T0>>::Finalize: Unpin,
    <C as Dispatch<T0>>::Handle: Unpin,
    <C as Fork<T3>>::Future: Unpin,
    <C as Fork<T3>>::Target: Unpin,
    <C as Fork<T3>>::Finalize: Unpin,
    <C as Dispatch<T3>>::Handle: Unpin,
    <C as Fork<T1>>::Future: Unpin,
    <C as Fork<T2>>::Future: Unpin,
    <C as Fork<T1>>::Finalize: Unpin,
    <C as Fork<T2>>::Finalize: Unpin,
    <C as Fork<T1>>::Target: Unpin,
    <C as Fork<T2>>::Target: Unpin,
    <C as Dispatch<T1>>::Handle: Unpin,
    <C as Dispatch<T2>>::Handle: Unpin
[src]

type Finalize = MapErr<TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>), (T0, T1, T2, T3)>, fn(_: <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>), (T0, T1, T2, T3)> as Future<C>>::Error) -> Tuple4UnravelError<<C as Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle)>>::Error, <<C as Fork<T0>>::Future as Future<C>>::Error, <<C as Fork<T1>>::Future as Future<C>>::Error, <<C as Fork<T2>>::Future as Future<C>>::Error, <<C as Fork<T3>>::Future as Future<C>>::Error, <Finalize<C, (T0, T1, T2, T3)> as Future<C>>::Error, <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>), (T0, T1, T2, T3)> as Future<C>>::Error>>

type Target = Tuple4Unravel<T0, T1, T2, T3, C>

impl<T0: Unpin, T1: Unpin, T2: Unpin, T3: Unpin, T4: Unpin, C: ?Sized + Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle)> + Fork<T0> + Fork<T4> + Fork<T1> + Fork<T2> + Fork<T3> + Unpin> Unravel<C> for (T0, T1, T2, T3, T4) where
    <C as Fork<T0>>::Future: Unpin,
    <C as Fork<T0>>::Target: Unpin,
    <C as Fork<T0>>::Finalize: Unpin,
    <C as Dispatch<T0>>::Handle: Unpin,
    <C as Fork<T4>>::Future: Unpin,
    <C as Fork<T4>>::Target: Unpin,
    <C as Fork<T4>>::Finalize: Unpin,
    <C as Dispatch<T4>>::Handle: Unpin,
    <C as Fork<T1>>::Future: Unpin,
    <C as Fork<T2>>::Future: Unpin,
    <C as Fork<T3>>::Future: Unpin,
    <C as Fork<T1>>::Finalize: Unpin,
    <C as Fork<T2>>::Finalize: Unpin,
    <C as Fork<T3>>::Finalize: Unpin,
    <C as Fork<T1>>::Target: Unpin,
    <C as Fork<T2>>::Target: Unpin,
    <C as Fork<T3>>::Target: Unpin,
    <C as Dispatch<T1>>::Handle: Unpin,
    <C as Dispatch<T2>>::Handle: Unpin,
    <C as Dispatch<T3>>::Handle: Unpin
[src]

type Finalize = MapErr<TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>), (T0, T1, T2, T3, T4)>, fn(_: <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>), (T0, T1, T2, T3, T4)> as Future<C>>::Error) -> Tuple5UnravelError<<C as Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle)>>::Error, <<C as Fork<T0>>::Future as Future<C>>::Error, <<C as Fork<T1>>::Future as Future<C>>::Error, <<C as Fork<T2>>::Future as Future<C>>::Error, <<C as Fork<T3>>::Future as Future<C>>::Error, <<C as Fork<T4>>::Future as Future<C>>::Error, <Finalize<C, (T0, T1, T2, T3, T4)> as Future<C>>::Error, <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>), (T0, T1, T2, T3, T4)> as Future<C>>::Error>>

type Target = Tuple5Unravel<T0, T1, T2, T3, T4, C>

impl<T0: Unpin, T1: Unpin, T2: Unpin, T3: Unpin, T4: Unpin, T5: Unpin, C: ?Sized + Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle)> + Fork<T0> + Fork<T5> + Fork<T1> + Fork<T2> + Fork<T3> + Fork<T4> + Unpin> Unravel<C> for (T0, T1, T2, T3, T4, T5) where
    <C as Fork<T0>>::Future: Unpin,
    <C as Fork<T0>>::Target: Unpin,
    <C as Fork<T0>>::Finalize: Unpin,
    <C as Dispatch<T0>>::Handle: Unpin,
    <C as Fork<T5>>::Future: Unpin,
    <C as Fork<T5>>::Target: Unpin,
    <C as Fork<T5>>::Finalize: Unpin,
    <C as Dispatch<T5>>::Handle: Unpin,
    <C as Fork<T1>>::Future: Unpin,
    <C as Fork<T2>>::Future: Unpin,
    <C as Fork<T3>>::Future: Unpin,
    <C as Fork<T4>>::Future: Unpin,
    <C as Fork<T1>>::Finalize: Unpin,
    <C as Fork<T2>>::Finalize: Unpin,
    <C as Fork<T3>>::Finalize: Unpin,
    <C as Fork<T4>>::Finalize: Unpin,
    <C as Fork<T1>>::Target: Unpin,
    <C as Fork<T2>>::Target: Unpin,
    <C as Fork<T3>>::Target: Unpin,
    <C as Fork<T4>>::Target: Unpin,
    <C as Dispatch<T1>>::Handle: Unpin,
    <C as Dispatch<T2>>::Handle: Unpin,
    <C as Dispatch<T3>>::Handle: Unpin,
    <C as Dispatch<T4>>::Handle: Unpin
[src]

type Finalize = MapErr<TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>), (T0, T1, T2, T3, T4, T5)>, fn(_: <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>), (T0, T1, T2, T3, T4, T5)> as Future<C>>::Error) -> Tuple6UnravelError<<C as Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle)>>::Error, <<C as Fork<T0>>::Future as Future<C>>::Error, <<C as Fork<T1>>::Future as Future<C>>::Error, <<C as Fork<T2>>::Future as Future<C>>::Error, <<C as Fork<T3>>::Future as Future<C>>::Error, <<C as Fork<T4>>::Future as Future<C>>::Error, <<C as Fork<T5>>::Future as Future<C>>::Error, <Finalize<C, (T0, T1, T2, T3, T4, T5)> as Future<C>>::Error, <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>), (T0, T1, T2, T3, T4, T5)> as Future<C>>::Error>>

type Target = Tuple6Unravel<T0, T1, T2, T3, T4, T5, C>

impl<T0: Unpin, T1: Unpin, T2: Unpin, T3: Unpin, T4: Unpin, T5: Unpin, T6: Unpin, C: ?Sized + Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle)> + Fork<T0> + Fork<T6> + Fork<T1> + Fork<T2> + Fork<T3> + Fork<T4> + Fork<T5> + Unpin> Unravel<C> for (T0, T1, T2, T3, T4, T5, T6) where
    <C as Fork<T0>>::Future: Unpin,
    <C as Fork<T0>>::Target: Unpin,
    <C as Fork<T0>>::Finalize: Unpin,
    <C as Dispatch<T0>>::Handle: Unpin,
    <C as Fork<T6>>::Future: Unpin,
    <C as Fork<T6>>::Target: Unpin,
    <C as Fork<T6>>::Finalize: Unpin,
    <C as Dispatch<T6>>::Handle: Unpin,
    <C as Fork<T1>>::Future: Unpin,
    <C as Fork<T2>>::Future: Unpin,
    <C as Fork<T3>>::Future: Unpin,
    <C as Fork<T4>>::Future: Unpin,
    <C as Fork<T5>>::Future: Unpin,
    <C as Fork<T1>>::Finalize: Unpin,
    <C as Fork<T2>>::Finalize: Unpin,
    <C as Fork<T3>>::Finalize: Unpin,
    <C as Fork<T4>>::Finalize: Unpin,
    <C as Fork<T5>>::Finalize: Unpin,
    <C as Fork<T1>>::Target: Unpin,
    <C as Fork<T2>>::Target: Unpin,
    <C as Fork<T3>>::Target: Unpin,
    <C as Fork<T4>>::Target: Unpin,
    <C as Fork<T5>>::Target: Unpin,
    <C as Dispatch<T1>>::Handle: Unpin,
    <C as Dispatch<T2>>::Handle: Unpin,
    <C as Dispatch<T3>>::Handle: Unpin,
    <C as Dispatch<T4>>::Handle: Unpin,
    <C as Dispatch<T5>>::Handle: Unpin
[src]

type Finalize = MapErr<TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6)>, fn(_: <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6)> as Future<C>>::Error) -> Tuple7UnravelError<<C as Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle)>>::Error, <<C as Fork<T0>>::Future as Future<C>>::Error, <<C as Fork<T1>>::Future as Future<C>>::Error, <<C as Fork<T2>>::Future as Future<C>>::Error, <<C as Fork<T3>>::Future as Future<C>>::Error, <<C as Fork<T4>>::Future as Future<C>>::Error, <<C as Fork<T5>>::Future as Future<C>>::Error, <<C as Fork<T6>>::Future as Future<C>>::Error, <Finalize<C, (T0, T1, T2, T3, T4, T5, T6)> as Future<C>>::Error, <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6)> as Future<C>>::Error>>

type Target = Tuple7Unravel<T0, T1, T2, T3, T4, T5, T6, C>

impl<T0: Unpin, T1: Unpin, T2: Unpin, T3: Unpin, T4: Unpin, T5: Unpin, T6: Unpin, T7: Unpin, C: ?Sized + Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle, <C as Dispatch<T7>>::Handle)> + Fork<T0> + Fork<T7> + Fork<T1> + Fork<T2> + Fork<T3> + Fork<T4> + Fork<T5> + Fork<T6> + Unpin> Unravel<C> for (T0, T1, T2, T3, T4, T5, T6, T7) where
    <C as Fork<T0>>::Future: Unpin,
    <C as Fork<T0>>::Target: Unpin,
    <C as Fork<T0>>::Finalize: Unpin,
    <C as Dispatch<T0>>::Handle: Unpin,
    <C as Fork<T7>>::Future: Unpin,
    <C as Fork<T7>>::Target: Unpin,
    <C as Fork<T7>>::Finalize: Unpin,
    <C as Dispatch<T7>>::Handle: Unpin,
    <C as Fork<T1>>::Future: Unpin,
    <C as Fork<T2>>::Future: Unpin,
    <C as Fork<T3>>::Future: Unpin,
    <C as Fork<T4>>::Future: Unpin,
    <C as Fork<T5>>::Future: Unpin,
    <C as Fork<T6>>::Future: Unpin,
    <C as Fork<T1>>::Finalize: Unpin,
    <C as Fork<T2>>::Finalize: Unpin,
    <C as Fork<T3>>::Finalize: Unpin,
    <C as Fork<T4>>::Finalize: Unpin,
    <C as Fork<T5>>::Finalize: Unpin,
    <C as Fork<T6>>::Finalize: Unpin,
    <C as Fork<T1>>::Target: Unpin,
    <C as Fork<T2>>::Target: Unpin,
    <C as Fork<T3>>::Target: Unpin,
    <C as Fork<T4>>::Target: Unpin,
    <C as Fork<T5>>::Target: Unpin,
    <C as Fork<T6>>::Target: Unpin,
    <C as Dispatch<T1>>::Handle: Unpin,
    <C as Dispatch<T2>>::Handle: Unpin,
    <C as Dispatch<T3>>::Handle: Unpin,
    <C as Dispatch<T4>>::Handle: Unpin,
    <C as Dispatch<T5>>::Handle: Unpin,
    <C as Dispatch<T6>>::Handle: Unpin
[src]

type Finalize = MapErr<TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7)>, fn(_: <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7)> as Future<C>>::Error) -> Tuple8UnravelError<<C as Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle, <C as Dispatch<T7>>::Handle)>>::Error, <<C as Fork<T0>>::Future as Future<C>>::Error, <<C as Fork<T1>>::Future as Future<C>>::Error, <<C as Fork<T2>>::Future as Future<C>>::Error, <<C as Fork<T3>>::Future as Future<C>>::Error, <<C as Fork<T4>>::Future as Future<C>>::Error, <<C as Fork<T5>>::Future as Future<C>>::Error, <<C as Fork<T6>>::Future as Future<C>>::Error, <<C as Fork<T7>>::Future as Future<C>>::Error, <Finalize<C, (T0, T1, T2, T3, T4, T5, T6, T7)> as Future<C>>::Error, <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7)> as Future<C>>::Error>>

type Target = Tuple8Unravel<T0, T1, T2, T3, T4, T5, T6, T7, C>

impl<T0: Unpin, T1: Unpin, T2: Unpin, T3: Unpin, T4: Unpin, T5: Unpin, T6: Unpin, T7: Unpin, T8: Unpin, C: ?Sized + Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle, <C as Dispatch<T7>>::Handle, <C as Dispatch<T8>>::Handle)> + Fork<T0> + Fork<T8> + Fork<T1> + Fork<T2> + Fork<T3> + Fork<T4> + Fork<T5> + Fork<T6> + Fork<T7> + Unpin> Unravel<C> for (T0, T1, T2, T3, T4, T5, T6, T7, T8) where
    <C as Fork<T0>>::Future: Unpin,
    <C as Fork<T0>>::Target: Unpin,
    <C as Fork<T0>>::Finalize: Unpin,
    <C as Dispatch<T0>>::Handle: Unpin,
    <C as Fork<T8>>::Future: Unpin,
    <C as Fork<T8>>::Target: Unpin,
    <C as Fork<T8>>::Finalize: Unpin,
    <C as Dispatch<T8>>::Handle: Unpin,
    <C as Fork<T1>>::Future: Unpin,
    <C as Fork<T2>>::Future: Unpin,
    <C as Fork<T3>>::Future: Unpin,
    <C as Fork<T4>>::Future: Unpin,
    <C as Fork<T5>>::Future: Unpin,
    <C as Fork<T6>>::Future: Unpin,
    <C as Fork<T7>>::Future: Unpin,
    <C as Fork<T1>>::Finalize: Unpin,
    <C as Fork<T2>>::Finalize: Unpin,
    <C as Fork<T3>>::Finalize: Unpin,
    <C as Fork<T4>>::Finalize: Unpin,
    <C as Fork<T5>>::Finalize: Unpin,
    <C as Fork<T6>>::Finalize: Unpin,
    <C as Fork<T7>>::Finalize: Unpin,
    <C as Fork<T1>>::Target: Unpin,
    <C as Fork<T2>>::Target: Unpin,
    <C as Fork<T3>>::Target: Unpin,
    <C as Fork<T4>>::Target: Unpin,
    <C as Fork<T5>>::Target: Unpin,
    <C as Fork<T6>>::Target: Unpin,
    <C as Fork<T7>>::Target: Unpin,
    <C as Dispatch<T1>>::Handle: Unpin,
    <C as Dispatch<T2>>::Handle: Unpin,
    <C as Dispatch<T3>>::Handle: Unpin,
    <C as Dispatch<T4>>::Handle: Unpin,
    <C as Dispatch<T5>>::Handle: Unpin,
    <C as Dispatch<T6>>::Handle: Unpin,
    <C as Dispatch<T7>>::Handle: Unpin
[src]

type Finalize = MapErr<TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8)>, fn(_: <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8)> as Future<C>>::Error) -> Tuple9UnravelError<<C as Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle, <C as Dispatch<T7>>::Handle, <C as Dispatch<T8>>::Handle)>>::Error, <<C as Fork<T0>>::Future as Future<C>>::Error, <<C as Fork<T1>>::Future as Future<C>>::Error, <<C as Fork<T2>>::Future as Future<C>>::Error, <<C as Fork<T3>>::Future as Future<C>>::Error, <<C as Fork<T4>>::Future as Future<C>>::Error, <<C as Fork<T5>>::Future as Future<C>>::Error, <<C as Fork<T6>>::Future as Future<C>>::Error, <<C as Fork<T7>>::Future as Future<C>>::Error, <<C as Fork<T8>>::Future as Future<C>>::Error, <Finalize<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8)> as Future<C>>::Error, <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8)> as Future<C>>::Error>>

type Target = Tuple9Unravel<T0, T1, T2, T3, T4, T5, T6, T7, T8, C>

impl<T0: Unpin, T1: Unpin, T2: Unpin, T3: Unpin, T4: Unpin, T5: Unpin, T6: Unpin, T7: Unpin, T8: Unpin, T9: Unpin, C: ?Sized + Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle, <C as Dispatch<T7>>::Handle, <C as Dispatch<T8>>::Handle, <C as Dispatch<T9>>::Handle)> + Fork<T0> + Fork<T9> + Fork<T1> + Fork<T2> + Fork<T3> + Fork<T4> + Fork<T5> + Fork<T6> + Fork<T7> + Fork<T8> + Unpin> Unravel<C> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) where
    <C as Fork<T0>>::Future: Unpin,
    <C as Fork<T0>>::Target: Unpin,
    <C as Fork<T0>>::Finalize: Unpin,
    <C as Dispatch<T0>>::Handle: Unpin,
    <C as Fork<T9>>::Future: Unpin,
    <C as Fork<T9>>::Target: Unpin,
    <C as Fork<T9>>::Finalize: Unpin,
    <C as Dispatch<T9>>::Handle: Unpin,
    <C as Fork<T1>>::Future: Unpin,
    <C as Fork<T2>>::Future: Unpin,
    <C as Fork<T3>>::Future: Unpin,
    <C as Fork<T4>>::Future: Unpin,
    <C as Fork<T5>>::Future: Unpin,
    <C as Fork<T6>>::Future: Unpin,
    <C as Fork<T7>>::Future: Unpin,
    <C as Fork<T8>>::Future: Unpin,
    <C as Fork<T1>>::Finalize: Unpin,
    <C as Fork<T2>>::Finalize: Unpin,
    <C as Fork<T3>>::Finalize: Unpin,
    <C as Fork<T4>>::Finalize: Unpin,
    <C as Fork<T5>>::Finalize: Unpin,
    <C as Fork<T6>>::Finalize: Unpin,
    <C as Fork<T7>>::Finalize: Unpin,
    <C as Fork<T8>>::Finalize: Unpin,
    <C as Fork<T1>>::Target: Unpin,
    <C as Fork<T2>>::Target: Unpin,
    <C as Fork<T3>>::Target: Unpin,
    <C as Fork<T4>>::Target: Unpin,
    <C as Fork<T5>>::Target: Unpin,
    <C as Fork<T6>>::Target: Unpin,
    <C as Fork<T7>>::Target: Unpin,
    <C as Fork<T8>>::Target: Unpin,
    <C as Dispatch<T1>>::Handle: Unpin,
    <C as Dispatch<T2>>::Handle: Unpin,
    <C as Dispatch<T3>>::Handle: Unpin,
    <C as Dispatch<T4>>::Handle: Unpin,
    <C as Dispatch<T5>>::Handle: Unpin,
    <C as Dispatch<T6>>::Handle: Unpin,
    <C as Dispatch<T7>>::Handle: Unpin,
    <C as Dispatch<T8>>::Handle: Unpin
[src]

type Finalize = MapErr<TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>, fn(_: <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> as Future<C>>::Error) -> Tuple10UnravelError<<C as Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle, <C as Dispatch<T7>>::Handle, <C as Dispatch<T8>>::Handle, <C as Dispatch<T9>>::Handle)>>::Error, <<C as Fork<T0>>::Future as Future<C>>::Error, <<C as Fork<T1>>::Future as Future<C>>::Error, <<C as Fork<T2>>::Future as Future<C>>::Error, <<C as Fork<T3>>::Future as Future<C>>::Error, <<C as Fork<T4>>::Future as Future<C>>::Error, <<C as Fork<T5>>::Future as Future<C>>::Error, <<C as Fork<T6>>::Future as Future<C>>::Error, <<C as Fork<T7>>::Future as Future<C>>::Error, <<C as Fork<T8>>::Future as Future<C>>::Error, <<C as Fork<T9>>::Future as Future<C>>::Error, <Finalize<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> as Future<C>>::Error, <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> as Future<C>>::Error>>

type Target = Tuple10Unravel<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, C>

impl<T0: Unpin, T1: Unpin, T2: Unpin, T3: Unpin, T4: Unpin, T5: Unpin, T6: Unpin, T7: Unpin, T8: Unpin, T9: Unpin, T10: Unpin, C: ?Sized + Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle, <C as Dispatch<T7>>::Handle, <C as Dispatch<T8>>::Handle, <C as Dispatch<T9>>::Handle, <C as Dispatch<T10>>::Handle)> + Fork<T0> + Fork<T10> + Fork<T1> + Fork<T2> + Fork<T3> + Fork<T4> + Fork<T5> + Fork<T6> + Fork<T7> + Fork<T8> + Fork<T9> + Unpin> Unravel<C> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) where
    <C as Fork<T0>>::Future: Unpin,
    <C as Fork<T0>>::Target: Unpin,
    <C as Fork<T0>>::Finalize: Unpin,
    <C as Dispatch<T0>>::Handle: Unpin,
    <C as Fork<T10>>::Future: Unpin,
    <C as Fork<T10>>::Target: Unpin,
    <C as Fork<T10>>::Finalize: Unpin,
    <C as Dispatch<T10>>::Handle: Unpin,
    <C as Fork<T1>>::Future: Unpin,
    <C as Fork<T2>>::Future: Unpin,
    <C as Fork<T3>>::Future: Unpin,
    <C as Fork<T4>>::Future: Unpin,
    <C as Fork<T5>>::Future: Unpin,
    <C as Fork<T6>>::Future: Unpin,
    <C as Fork<T7>>::Future: Unpin,
    <C as Fork<T8>>::Future: Unpin,
    <C as Fork<T9>>::Future: Unpin,
    <C as Fork<T1>>::Finalize: Unpin,
    <C as Fork<T2>>::Finalize: Unpin,
    <C as Fork<T3>>::Finalize: Unpin,
    <C as Fork<T4>>::Finalize: Unpin,
    <C as Fork<T5>>::Finalize: Unpin,
    <C as Fork<T6>>::Finalize: Unpin,
    <C as Fork<T7>>::Finalize: Unpin,
    <C as Fork<T8>>::Finalize: Unpin,
    <C as Fork<T9>>::Finalize: Unpin,
    <C as Fork<T1>>::Target: Unpin,
    <C as Fork<T2>>::Target: Unpin,
    <C as Fork<T3>>::Target: Unpin,
    <C as Fork<T4>>::Target: Unpin,
    <C as Fork<T5>>::Target: Unpin,
    <C as Fork<T6>>::Target: Unpin,
    <C as Fork<T7>>::Target: Unpin,
    <C as Fork<T8>>::Target: Unpin,
    <C as Fork<T9>>::Target: Unpin,
    <C as Dispatch<T1>>::Handle: Unpin,
    <C as Dispatch<T2>>::Handle: Unpin,
    <C as Dispatch<T3>>::Handle: Unpin,
    <C as Dispatch<T4>>::Handle: Unpin,
    <C as Dispatch<T5>>::Handle: Unpin,
    <C as Dispatch<T6>>::Handle: Unpin,
    <C as Dispatch<T7>>::Handle: Unpin,
    <C as Dispatch<T8>>::Handle: Unpin,
    <C as Dispatch<T9>>::Handle: Unpin
[src]

type Finalize = MapErr<TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>, Option<<C as Fork<T10>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>, fn(_: <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>, Option<<C as Fork<T10>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> as Future<C>>::Error) -> Tuple11UnravelError<<C as Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle, <C as Dispatch<T7>>::Handle, <C as Dispatch<T8>>::Handle, <C as Dispatch<T9>>::Handle, <C as Dispatch<T10>>::Handle)>>::Error, <<C as Fork<T0>>::Future as Future<C>>::Error, <<C as Fork<T1>>::Future as Future<C>>::Error, <<C as Fork<T2>>::Future as Future<C>>::Error, <<C as Fork<T3>>::Future as Future<C>>::Error, <<C as Fork<T4>>::Future as Future<C>>::Error, <<C as Fork<T5>>::Future as Future<C>>::Error, <<C as Fork<T6>>::Future as Future<C>>::Error, <<C as Fork<T7>>::Future as Future<C>>::Error, <<C as Fork<T8>>::Future as Future<C>>::Error, <<C as Fork<T9>>::Future as Future<C>>::Error, <<C as Fork<T10>>::Future as Future<C>>::Error, <Finalize<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> as Future<C>>::Error, <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>, Option<<C as Fork<T10>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> as Future<C>>::Error>>

type Target = Tuple11Unravel<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, C>

impl<T0: Unpin, T1: Unpin, T2: Unpin, T3: Unpin, T4: Unpin, T5: Unpin, T6: Unpin, T7: Unpin, T8: Unpin, T9: Unpin, T10: Unpin, T11: Unpin, C: ?Sized + Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle, <C as Dispatch<T7>>::Handle, <C as Dispatch<T8>>::Handle, <C as Dispatch<T9>>::Handle, <C as Dispatch<T10>>::Handle, <C as Dispatch<T11>>::Handle)> + Fork<T0> + Fork<T11> + Fork<T1> + Fork<T2> + Fork<T3> + Fork<T4> + Fork<T5> + Fork<T6> + Fork<T7> + Fork<T8> + Fork<T9> + Fork<T10> + Unpin> Unravel<C> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) where
    <C as Fork<T0>>::Future: Unpin,
    <C as Fork<T0>>::Target: Unpin,
    <C as Fork<T0>>::Finalize: Unpin,
    <C as Dispatch<T0>>::Handle: Unpin,
    <C as Fork<T11>>::Future: Unpin,
    <C as Fork<T11>>::Target: Unpin,
    <C as Fork<T11>>::Finalize: Unpin,
    <C as Dispatch<T11>>::Handle: Unpin,
    <C as Fork<T1>>::Future: Unpin,
    <C as Fork<T2>>::Future: Unpin,
    <C as Fork<T3>>::Future: Unpin,
    <C as Fork<T4>>::Future: Unpin,
    <C as Fork<T5>>::Future: Unpin,
    <C as Fork<T6>>::Future: Unpin,
    <C as Fork<T7>>::Future: Unpin,
    <C as Fork<T8>>::Future: Unpin,
    <C as Fork<T9>>::Future: Unpin,
    <C as Fork<T10>>::Future: Unpin,
    <C as Fork<T1>>::Finalize: Unpin,
    <C as Fork<T2>>::Finalize: Unpin,
    <C as Fork<T3>>::Finalize: Unpin,
    <C as Fork<T4>>::Finalize: Unpin,
    <C as Fork<T5>>::Finalize: Unpin,
    <C as Fork<T6>>::Finalize: Unpin,
    <C as Fork<T7>>::Finalize: Unpin,
    <C as Fork<T8>>::Finalize: Unpin,
    <C as Fork<T9>>::Finalize: Unpin,
    <C as Fork<T10>>::Finalize: Unpin,
    <C as Fork<T1>>::Target: Unpin,
    <C as Fork<T2>>::Target: Unpin,
    <C as Fork<T3>>::Target: Unpin,
    <C as Fork<T4>>::Target: Unpin,
    <C as Fork<T5>>::Target: Unpin,
    <C as Fork<T6>>::Target: Unpin,
    <C as Fork<T7>>::Target: Unpin,
    <C as Fork<T8>>::Target: Unpin,
    <C as Fork<T9>>::Target: Unpin,
    <C as Fork<T10>>::Target: Unpin,
    <C as Dispatch<T1>>::Handle: Unpin,
    <C as Dispatch<T2>>::Handle: Unpin,
    <C as Dispatch<T3>>::Handle: Unpin,
    <C as Dispatch<T4>>::Handle: Unpin,
    <C as Dispatch<T5>>::Handle: Unpin,
    <C as Dispatch<T6>>::Handle: Unpin,
    <C as Dispatch<T7>>::Handle: Unpin,
    <C as Dispatch<T8>>::Handle: Unpin,
    <C as Dispatch<T9>>::Handle: Unpin,
    <C as Dispatch<T10>>::Handle: Unpin
[src]

type Finalize = MapErr<TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>, Option<<C as Fork<T10>>::Finalize>, Option<<C as Fork<T11>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>, fn(_: <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>, Option<<C as Fork<T10>>::Finalize>, Option<<C as Fork<T11>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> as Future<C>>::Error) -> Tuple12UnravelError<<C as Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle, <C as Dispatch<T7>>::Handle, <C as Dispatch<T8>>::Handle, <C as Dispatch<T9>>::Handle, <C as Dispatch<T10>>::Handle, <C as Dispatch<T11>>::Handle)>>::Error, <<C as Fork<T0>>::Future as Future<C>>::Error, <<C as Fork<T1>>::Future as Future<C>>::Error, <<C as Fork<T2>>::Future as Future<C>>::Error, <<C as Fork<T3>>::Future as Future<C>>::Error, <<C as Fork<T4>>::Future as Future<C>>::Error, <<C as Fork<T5>>::Future as Future<C>>::Error, <<C as Fork<T6>>::Future as Future<C>>::Error, <<C as Fork<T7>>::Future as Future<C>>::Error, <<C as Fork<T8>>::Future as Future<C>>::Error, <<C as Fork<T9>>::Future as Future<C>>::Error, <<C as Fork<T10>>::Future as Future<C>>::Error, <<C as Fork<T11>>::Future as Future<C>>::Error, <Finalize<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> as Future<C>>::Error, <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>, Option<<C as Fork<T10>>::Finalize>, Option<<C as Fork<T11>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> as Future<C>>::Error>>

type Target = Tuple12Unravel<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, C>

impl<T0: Unpin, T1: Unpin, T2: Unpin, T3: Unpin, T4: Unpin, T5: Unpin, T6: Unpin, T7: Unpin, T8: Unpin, T9: Unpin, T10: Unpin, T11: Unpin, T12: Unpin, C: ?Sized + Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle, <C as Dispatch<T7>>::Handle, <C as Dispatch<T8>>::Handle, <C as Dispatch<T9>>::Handle, <C as Dispatch<T10>>::Handle, <C as Dispatch<T11>>::Handle, <C as Dispatch<T12>>::Handle)> + Fork<T0> + Fork<T12> + Fork<T1> + Fork<T2> + Fork<T3> + Fork<T4> + Fork<T5> + Fork<T6> + Fork<T7> + Fork<T8> + Fork<T9> + Fork<T10> + Fork<T11> + Unpin> Unravel<C> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) where
    <C as Fork<T0>>::Future: Unpin,
    <C as Fork<T0>>::Target: Unpin,
    <C as Fork<T0>>::Finalize: Unpin,
    <C as Dispatch<T0>>::Handle: Unpin,
    <C as Fork<T12>>::Future: Unpin,
    <C as Fork<T12>>::Target: Unpin,
    <C as Fork<T12>>::Finalize: Unpin,
    <C as Dispatch<T12>>::Handle: Unpin,
    <C as Fork<T1>>::Future: Unpin,
    <C as Fork<T2>>::Future: Unpin,
    <C as Fork<T3>>::Future: Unpin,
    <C as Fork<T4>>::Future: Unpin,
    <C as Fork<T5>>::Future: Unpin,
    <C as Fork<T6>>::Future: Unpin,
    <C as Fork<T7>>::Future: Unpin,
    <C as Fork<T8>>::Future: Unpin,
    <C as Fork<T9>>::Future: Unpin,
    <C as Fork<T10>>::Future: Unpin,
    <C as Fork<T11>>::Future: Unpin,
    <C as Fork<T1>>::Finalize: Unpin,
    <C as Fork<T2>>::Finalize: Unpin,
    <C as Fork<T3>>::Finalize: Unpin,
    <C as Fork<T4>>::Finalize: Unpin,
    <C as Fork<T5>>::Finalize: Unpin,
    <C as Fork<T6>>::Finalize: Unpin,
    <C as Fork<T7>>::Finalize: Unpin,
    <C as Fork<T8>>::Finalize: Unpin,
    <C as Fork<T9>>::Finalize: Unpin,
    <C as Fork<T10>>::Finalize: Unpin,
    <C as Fork<T11>>::Finalize: Unpin,
    <C as Fork<T1>>::Target: Unpin,
    <C as Fork<T2>>::Target: Unpin,
    <C as Fork<T3>>::Target: Unpin,
    <C as Fork<T4>>::Target: Unpin,
    <C as Fork<T5>>::Target: Unpin,
    <C as Fork<T6>>::Target: Unpin,
    <C as Fork<T7>>::Target: Unpin,
    <C as Fork<T8>>::Target: Unpin,
    <C as Fork<T9>>::Target: Unpin,
    <C as Fork<T10>>::Target: Unpin,
    <C as Fork<T11>>::Target: Unpin,
    <C as Dispatch<T1>>::Handle: Unpin,
    <C as Dispatch<T2>>::Handle: Unpin,
    <C as Dispatch<T3>>::Handle: Unpin,
    <C as Dispatch<T4>>::Handle: Unpin,
    <C as Dispatch<T5>>::Handle: Unpin,
    <C as Dispatch<T6>>::Handle: Unpin,
    <C as Dispatch<T7>>::Handle: Unpin,
    <C as Dispatch<T8>>::Handle: Unpin,
    <C as Dispatch<T9>>::Handle: Unpin,
    <C as Dispatch<T10>>::Handle: Unpin,
    <C as Dispatch<T11>>::Handle: Unpin
[src]

type Finalize = MapErr<TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>, Option<<C as Fork<T10>>::Finalize>, Option<<C as Fork<T11>>::Finalize>, Option<<C as Fork<T12>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>, fn(_: <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>, Option<<C as Fork<T10>>::Finalize>, Option<<C as Fork<T11>>::Finalize>, Option<<C as Fork<T12>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> as Future<C>>::Error) -> Tuple13UnravelError<<C as Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle, <C as Dispatch<T7>>::Handle, <C as Dispatch<T8>>::Handle, <C as Dispatch<T9>>::Handle, <C as Dispatch<T10>>::Handle, <C as Dispatch<T11>>::Handle, <C as Dispatch<T12>>::Handle)>>::Error, <<C as Fork<T0>>::Future as Future<C>>::Error, <<C as Fork<T1>>::Future as Future<C>>::Error, <<C as Fork<T2>>::Future as Future<C>>::Error, <<C as Fork<T3>>::Future as Future<C>>::Error, <<C as Fork<T4>>::Future as Future<C>>::Error, <<C as Fork<T5>>::Future as Future<C>>::Error, <<C as Fork<T6>>::Future as Future<C>>::Error, <<C as Fork<T7>>::Future as Future<C>>::Error, <<C as Fork<T8>>::Future as Future<C>>::Error, <<C as Fork<T9>>::Future as Future<C>>::Error, <<C as Fork<T10>>::Future as Future<C>>::Error, <<C as Fork<T11>>::Future as Future<C>>::Error, <<C as Fork<T12>>::Future as Future<C>>::Error, <Finalize<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> as Future<C>>::Error, <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>, Option<<C as Fork<T10>>::Finalize>, Option<<C as Fork<T11>>::Finalize>, Option<<C as Fork<T12>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> as Future<C>>::Error>>

type Target = Tuple13Unravel<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, C>

impl<T0: Unpin, T1: Unpin, T2: Unpin, T3: Unpin, T4: Unpin, T5: Unpin, T6: Unpin, T7: Unpin, T8: Unpin, T9: Unpin, T10: Unpin, T11: Unpin, T12: Unpin, T13: Unpin, C: ?Sized + Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle, <C as Dispatch<T7>>::Handle, <C as Dispatch<T8>>::Handle, <C as Dispatch<T9>>::Handle, <C as Dispatch<T10>>::Handle, <C as Dispatch<T11>>::Handle, <C as Dispatch<T12>>::Handle, <C as Dispatch<T13>>::Handle)> + Fork<T0> + Fork<T13> + Fork<T1> + Fork<T2> + Fork<T3> + Fork<T4> + Fork<T5> + Fork<T6> + Fork<T7> + Fork<T8> + Fork<T9> + Fork<T10> + Fork<T11> + Fork<T12> + Unpin> Unravel<C> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) where
    <C as Fork<T0>>::Future: Unpin,
    <C as Fork<T0>>::Target: Unpin,
    <C as Fork<T0>>::Finalize: Unpin,
    <C as Dispatch<T0>>::Handle: Unpin,
    <C as Fork<T13>>::Future: Unpin,
    <C as Fork<T13>>::Target: Unpin,
    <C as Fork<T13>>::Finalize: Unpin,
    <C as Dispatch<T13>>::Handle: Unpin,
    <C as Fork<T1>>::Future: Unpin,
    <C as Fork<T2>>::Future: Unpin,
    <C as Fork<T3>>::Future: Unpin,
    <C as Fork<T4>>::Future: Unpin,
    <C as Fork<T5>>::Future: Unpin,
    <C as Fork<T6>>::Future: Unpin,
    <C as Fork<T7>>::Future: Unpin,
    <C as Fork<T8>>::Future: Unpin,
    <C as Fork<T9>>::Future: Unpin,
    <C as Fork<T10>>::Future: Unpin,
    <C as Fork<T11>>::Future: Unpin,
    <C as Fork<T12>>::Future: Unpin,
    <C as Fork<T1>>::Finalize: Unpin,
    <C as Fork<T2>>::Finalize: Unpin,
    <C as Fork<T3>>::Finalize: Unpin,
    <C as Fork<T4>>::Finalize: Unpin,
    <C as Fork<T5>>::Finalize: Unpin,
    <C as Fork<T6>>::Finalize: Unpin,
    <C as Fork<T7>>::Finalize: Unpin,
    <C as Fork<T8>>::Finalize: Unpin,
    <C as Fork<T9>>::Finalize: Unpin,
    <C as Fork<T10>>::Finalize: Unpin,
    <C as Fork<T11>>::Finalize: Unpin,
    <C as Fork<T12>>::Finalize: Unpin,
    <C as Fork<T1>>::Target: Unpin,
    <C as Fork<T2>>::Target: Unpin,
    <C as Fork<T3>>::Target: Unpin,
    <C as Fork<T4>>::Target: Unpin,
    <C as Fork<T5>>::Target: Unpin,
    <C as Fork<T6>>::Target: Unpin,
    <C as Fork<T7>>::Target: Unpin,
    <C as Fork<T8>>::Target: Unpin,
    <C as Fork<T9>>::Target: Unpin,
    <C as Fork<T10>>::Target: Unpin,
    <C as Fork<T11>>::Target: Unpin,
    <C as Fork<T12>>::Target: Unpin,
    <C as Dispatch<T1>>::Handle: Unpin,
    <C as Dispatch<T2>>::Handle: Unpin,
    <C as Dispatch<T3>>::Handle: Unpin,
    <C as Dispatch<T4>>::Handle: Unpin,
    <C as Dispatch<T5>>::Handle: Unpin,
    <C as Dispatch<T6>>::Handle: Unpin,
    <C as Dispatch<T7>>::Handle: Unpin,
    <C as Dispatch<T8>>::Handle: Unpin,
    <C as Dispatch<T9>>::Handle: Unpin,
    <C as Dispatch<T10>>::Handle: Unpin,
    <C as Dispatch<T11>>::Handle: Unpin,
    <C as Dispatch<T12>>::Handle: Unpin
[src]

type Finalize = MapErr<TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>, Option<<C as Fork<T10>>::Finalize>, Option<<C as Fork<T11>>::Finalize>, Option<<C as Fork<T12>>::Finalize>, Option<<C as Fork<T13>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>, fn(_: <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>, Option<<C as Fork<T10>>::Finalize>, Option<<C as Fork<T11>>::Finalize>, Option<<C as Fork<T12>>::Finalize>, Option<<C as Fork<T13>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> as Future<C>>::Error) -> Tuple14UnravelError<<C as Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle, <C as Dispatch<T7>>::Handle, <C as Dispatch<T8>>::Handle, <C as Dispatch<T9>>::Handle, <C as Dispatch<T10>>::Handle, <C as Dispatch<T11>>::Handle, <C as Dispatch<T12>>::Handle, <C as Dispatch<T13>>::Handle)>>::Error, <<C as Fork<T0>>::Future as Future<C>>::Error, <<C as Fork<T1>>::Future as Future<C>>::Error, <<C as Fork<T2>>::Future as Future<C>>::Error, <<C as Fork<T3>>::Future as Future<C>>::Error, <<C as Fork<T4>>::Future as Future<C>>::Error, <<C as Fork<T5>>::Future as Future<C>>::Error, <<C as Fork<T6>>::Future as Future<C>>::Error, <<C as Fork<T7>>::Future as Future<C>>::Error, <<C as Fork<T8>>::Future as Future<C>>::Error, <<C as Fork<T9>>::Future as Future<C>>::Error, <<C as Fork<T10>>::Future as Future<C>>::Error, <<C as Fork<T11>>::Future as Future<C>>::Error, <<C as Fork<T12>>::Future as Future<C>>::Error, <<C as Fork<T13>>::Future as Future<C>>::Error, <Finalize<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> as Future<C>>::Error, <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>, Option<<C as Fork<T10>>::Finalize>, Option<<C as Fork<T11>>::Finalize>, Option<<C as Fork<T12>>::Finalize>, Option<<C as Fork<T13>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> as Future<C>>::Error>>

type Target = Tuple14Unravel<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, C>

impl<T0: Unpin, T1: Unpin, T2: Unpin, T3: Unpin, T4: Unpin, T5: Unpin, T6: Unpin, T7: Unpin, T8: Unpin, T9: Unpin, T10: Unpin, T11: Unpin, T12: Unpin, T13: Unpin, T14: Unpin, C: ?Sized + Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle, <C as Dispatch<T7>>::Handle, <C as Dispatch<T8>>::Handle, <C as Dispatch<T9>>::Handle, <C as Dispatch<T10>>::Handle, <C as Dispatch<T11>>::Handle, <C as Dispatch<T12>>::Handle, <C as Dispatch<T13>>::Handle, <C as Dispatch<T14>>::Handle)> + Fork<T0> + Fork<T14> + Fork<T1> + Fork<T2> + Fork<T3> + Fork<T4> + Fork<T5> + Fork<T6> + Fork<T7> + Fork<T8> + Fork<T9> + Fork<T10> + Fork<T11> + Fork<T12> + Fork<T13> + Unpin> Unravel<C> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) where
    <C as Fork<T0>>::Future: Unpin,
    <C as Fork<T0>>::Target: Unpin,
    <C as Fork<T0>>::Finalize: Unpin,
    <C as Dispatch<T0>>::Handle: Unpin,
    <C as Fork<T14>>::Future: Unpin,
    <C as Fork<T14>>::Target: Unpin,
    <C as Fork<T14>>::Finalize: Unpin,
    <C as Dispatch<T14>>::Handle: Unpin,
    <C as Fork<T1>>::Future: Unpin,
    <C as Fork<T2>>::Future: Unpin,
    <C as Fork<T3>>::Future: Unpin,
    <C as Fork<T4>>::Future: Unpin,
    <C as Fork<T5>>::Future: Unpin,
    <C as Fork<T6>>::Future: Unpin,
    <C as Fork<T7>>::Future: Unpin,
    <C as Fork<T8>>::Future: Unpin,
    <C as Fork<T9>>::Future: Unpin,
    <C as Fork<T10>>::Future: Unpin,
    <C as Fork<T11>>::Future: Unpin,
    <C as Fork<T12>>::Future: Unpin,
    <C as Fork<T13>>::Future: Unpin,
    <C as Fork<T1>>::Finalize: Unpin,
    <C as Fork<T2>>::Finalize: Unpin,
    <C as Fork<T3>>::Finalize: Unpin,
    <C as Fork<T4>>::Finalize: Unpin,
    <C as Fork<T5>>::Finalize: Unpin,
    <C as Fork<T6>>::Finalize: Unpin,
    <C as Fork<T7>>::Finalize: Unpin,
    <C as Fork<T8>>::Finalize: Unpin,
    <C as Fork<T9>>::Finalize: Unpin,
    <C as Fork<T10>>::Finalize: Unpin,
    <C as Fork<T11>>::Finalize: Unpin,
    <C as Fork<T12>>::Finalize: Unpin,
    <C as Fork<T13>>::Finalize: Unpin,
    <C as Fork<T1>>::Target: Unpin,
    <C as Fork<T2>>::Target: Unpin,
    <C as Fork<T3>>::Target: Unpin,
    <C as Fork<T4>>::Target: Unpin,
    <C as Fork<T5>>::Target: Unpin,
    <C as Fork<T6>>::Target: Unpin,
    <C as Fork<T7>>::Target: Unpin,
    <C as Fork<T8>>::Target: Unpin,
    <C as Fork<T9>>::Target: Unpin,
    <C as Fork<T10>>::Target: Unpin,
    <C as Fork<T11>>::Target: Unpin,
    <C as Fork<T12>>::Target: Unpin,
    <C as Fork<T13>>::Target: Unpin,
    <C as Dispatch<T1>>::Handle: Unpin,
    <C as Dispatch<T2>>::Handle: Unpin,
    <C as Dispatch<T3>>::Handle: Unpin,
    <C as Dispatch<T4>>::Handle: Unpin,
    <C as Dispatch<T5>>::Handle: Unpin,
    <C as Dispatch<T6>>::Handle: Unpin,
    <C as Dispatch<T7>>::Handle: Unpin,
    <C as Dispatch<T8>>::Handle: Unpin,
    <C as Dispatch<T9>>::Handle: Unpin,
    <C as Dispatch<T10>>::Handle: Unpin,
    <C as Dispatch<T11>>::Handle: Unpin,
    <C as Dispatch<T12>>::Handle: Unpin,
    <C as Dispatch<T13>>::Handle: Unpin
[src]

type Finalize = MapErr<TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>, Option<<C as Fork<T10>>::Finalize>, Option<<C as Fork<T11>>::Finalize>, Option<<C as Fork<T12>>::Finalize>, Option<<C as Fork<T13>>::Finalize>, Option<<C as Fork<T14>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>, fn(_: <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>, Option<<C as Fork<T10>>::Finalize>, Option<<C as Fork<T11>>::Finalize>, Option<<C as Fork<T12>>::Finalize>, Option<<C as Fork<T13>>::Finalize>, Option<<C as Fork<T14>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> as Future<C>>::Error) -> Tuple15UnravelError<<C as Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle, <C as Dispatch<T7>>::Handle, <C as Dispatch<T8>>::Handle, <C as Dispatch<T9>>::Handle, <C as Dispatch<T10>>::Handle, <C as Dispatch<T11>>::Handle, <C as Dispatch<T12>>::Handle, <C as Dispatch<T13>>::Handle, <C as Dispatch<T14>>::Handle)>>::Error, <<C as Fork<T0>>::Future as Future<C>>::Error, <<C as Fork<T1>>::Future as Future<C>>::Error, <<C as Fork<T2>>::Future as Future<C>>::Error, <<C as Fork<T3>>::Future as Future<C>>::Error, <<C as Fork<T4>>::Future as Future<C>>::Error, <<C as Fork<T5>>::Future as Future<C>>::Error, <<C as Fork<T6>>::Future as Future<C>>::Error, <<C as Fork<T7>>::Future as Future<C>>::Error, <<C as Fork<T8>>::Future as Future<C>>::Error, <<C as Fork<T9>>::Future as Future<C>>::Error, <<C as Fork<T10>>::Future as Future<C>>::Error, <<C as Fork<T11>>::Future as Future<C>>::Error, <<C as Fork<T12>>::Future as Future<C>>::Error, <<C as Fork<T13>>::Future as Future<C>>::Error, <<C as Fork<T14>>::Future as Future<C>>::Error, <Finalize<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> as Future<C>>::Error, <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>, Option<<C as Fork<T10>>::Finalize>, Option<<C as Fork<T11>>::Finalize>, Option<<C as Fork<T12>>::Finalize>, Option<<C as Fork<T13>>::Finalize>, Option<<C as Fork<T14>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> as Future<C>>::Error>>

type Target = Tuple15Unravel<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, C>

impl<T0: Unpin, T1: Unpin, T2: Unpin, T3: Unpin, T4: Unpin, T5: Unpin, T6: Unpin, T7: Unpin, T8: Unpin, T9: Unpin, T10: Unpin, T11: Unpin, T12: Unpin, T13: Unpin, T14: Unpin, T15: Unpin, C: ?Sized + Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle, <C as Dispatch<T7>>::Handle, <C as Dispatch<T8>>::Handle, <C as Dispatch<T9>>::Handle, <C as Dispatch<T10>>::Handle, <C as Dispatch<T11>>::Handle, <C as Dispatch<T12>>::Handle, <C as Dispatch<T13>>::Handle, <C as Dispatch<T14>>::Handle, <C as Dispatch<T15>>::Handle)> + Fork<T0> + Fork<T15> + Fork<T1> + Fork<T2> + Fork<T3> + Fork<T4> + Fork<T5> + Fork<T6> + Fork<T7> + Fork<T8> + Fork<T9> + Fork<T10> + Fork<T11> + Fork<T12> + Fork<T13> + Fork<T14> + Unpin> Unravel<C> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) where
    <C as Fork<T0>>::Future: Unpin,
    <C as Fork<T0>>::Target: Unpin,
    <C as Fork<T0>>::Finalize: Unpin,
    <C as Dispatch<T0>>::Handle: Unpin,
    <C as Fork<T15>>::Future: Unpin,
    <C as Fork<T15>>::Target: Unpin,
    <C as Fork<T15>>::Finalize: Unpin,
    <C as Dispatch<T15>>::Handle: Unpin,
    <C as Fork<T1>>::Future: Unpin,
    <C as Fork<T2>>::Future: Unpin,
    <C as Fork<T3>>::Future: Unpin,
    <C as Fork<T4>>::Future: Unpin,
    <C as Fork<T5>>::Future: Unpin,
    <C as Fork<T6>>::Future: Unpin,
    <C as Fork<T7>>::Future: Unpin,
    <C as Fork<T8>>::Future: Unpin,
    <C as Fork<T9>>::Future: Unpin,
    <C as Fork<T10>>::Future: Unpin,
    <C as Fork<T11>>::Future: Unpin,
    <C as Fork<T12>>::Future: Unpin,
    <C as Fork<T13>>::Future: Unpin,
    <C as Fork<T14>>::Future: Unpin,
    <C as Fork<T1>>::Finalize: Unpin,
    <C as Fork<T2>>::Finalize: Unpin,
    <C as Fork<T3>>::Finalize: Unpin,
    <C as Fork<T4>>::Finalize: Unpin,
    <C as Fork<T5>>::Finalize: Unpin,
    <C as Fork<T6>>::Finalize: Unpin,
    <C as Fork<T7>>::Finalize: Unpin,
    <C as Fork<T8>>::Finalize: Unpin,
    <C as Fork<T9>>::Finalize: Unpin,
    <C as Fork<T10>>::Finalize: Unpin,
    <C as Fork<T11>>::Finalize: Unpin,
    <C as Fork<T12>>::Finalize: Unpin,
    <C as Fork<T13>>::Finalize: Unpin,
    <C as Fork<T14>>::Finalize: Unpin,
    <C as Fork<T1>>::Target: Unpin,
    <C as Fork<T2>>::Target: Unpin,
    <C as Fork<T3>>::Target: Unpin,
    <C as Fork<T4>>::Target: Unpin,
    <C as Fork<T5>>::Target: Unpin,
    <C as Fork<T6>>::Target: Unpin,
    <C as Fork<T7>>::Target: Unpin,
    <C as Fork<T8>>::Target: Unpin,
    <C as Fork<T9>>::Target: Unpin,
    <C as Fork<T10>>::Target: Unpin,
    <C as Fork<T11>>::Target: Unpin,
    <C as Fork<T12>>::Target: Unpin,
    <C as Fork<T13>>::Target: Unpin,
    <C as Fork<T14>>::Target: Unpin,
    <C as Dispatch<T1>>::Handle: Unpin,
    <C as Dispatch<T2>>::Handle: Unpin,
    <C as Dispatch<T3>>::Handle: Unpin,
    <C as Dispatch<T4>>::Handle: Unpin,
    <C as Dispatch<T5>>::Handle: Unpin,
    <C as Dispatch<T6>>::Handle: Unpin,
    <C as Dispatch<T7>>::Handle: Unpin,
    <C as Dispatch<T8>>::Handle: Unpin,
    <C as Dispatch<T9>>::Handle: Unpin,
    <C as Dispatch<T10>>::Handle: Unpin,
    <C as Dispatch<T11>>::Handle: Unpin,
    <C as Dispatch<T12>>::Handle: Unpin,
    <C as Dispatch<T13>>::Handle: Unpin,
    <C as Dispatch<T14>>::Handle: Unpin
[src]

type Finalize = MapErr<TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>, Option<<C as Fork<T10>>::Finalize>, Option<<C as Fork<T11>>::Finalize>, Option<<C as Fork<T12>>::Finalize>, Option<<C as Fork<T13>>::Finalize>, Option<<C as Fork<T14>>::Finalize>, Option<<C as Fork<T15>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>, fn(_: <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>, Option<<C as Fork<T10>>::Finalize>, Option<<C as Fork<T11>>::Finalize>, Option<<C as Fork<T12>>::Finalize>, Option<<C as Fork<T13>>::Finalize>, Option<<C as Fork<T14>>::Finalize>, Option<<C as Fork<T15>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> as Future<C>>::Error) -> Tuple16UnravelError<<C as Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle, <C as Dispatch<T7>>::Handle, <C as Dispatch<T8>>::Handle, <C as Dispatch<T9>>::Handle, <C as Dispatch<T10>>::Handle, <C as Dispatch<T11>>::Handle, <C as Dispatch<T12>>::Handle, <C as Dispatch<T13>>::Handle, <C as Dispatch<T14>>::Handle, <C as Dispatch<T15>>::Handle)>>::Error, <<C as Fork<T0>>::Future as Future<C>>::Error, <<C as Fork<T1>>::Future as Future<C>>::Error, <<C as Fork<T2>>::Future as Future<C>>::Error, <<C as Fork<T3>>::Future as Future<C>>::Error, <<C as Fork<T4>>::Future as Future<C>>::Error, <<C as Fork<T5>>::Future as Future<C>>::Error, <<C as Fork<T6>>::Future as Future<C>>::Error, <<C as Fork<T7>>::Future as Future<C>>::Error, <<C as Fork<T8>>::Future as Future<C>>::Error, <<C as Fork<T9>>::Future as Future<C>>::Error, <<C as Fork<T10>>::Future as Future<C>>::Error, <<C as Fork<T11>>::Future as Future<C>>::Error, <<C as Fork<T12>>::Future as Future<C>>::Error, <<C as Fork<T13>>::Future as Future<C>>::Error, <<C as Fork<T14>>::Future as Future<C>>::Error, <<C as Fork<T15>>::Future as Future<C>>::Error, <Finalize<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> as Future<C>>::Error, <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>, Option<<C as Fork<T10>>::Finalize>, Option<<C as Fork<T11>>::Finalize>, Option<<C as Fork<T12>>::Finalize>, Option<<C as Fork<T13>>::Finalize>, Option<<C as Fork<T14>>::Finalize>, Option<<C as Fork<T15>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> as Future<C>>::Error>>

type Target = Tuple16Unravel<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, C>

impl<C: ?Sized + Write<<C as Dispatch<([String; 2], Vec<[String; 2]>)>>::Handle> + Fork<([String; 2], Vec<[String; 2]>)> + Unpin> Unravel<C> for Box<dyn Error> where
    C::Future: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin
[src]

type Finalize = <FlatUnravel<([String; 2], Vec<[String; 2]>), C> as Future<C>>::Ok

type Target = FlatUnravel<([String; 2], Vec<[String; 2]>), C>

impl<C: ?Sized + Write<<C as Dispatch<([String; 2], Vec<[String; 2]>)>>::Handle> + Fork<([String; 2], Vec<[String; 2]>)> + Unpin> Unravel<C> for Box<dyn Error + Sync> where
    C::Future: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin
[src]

type Finalize = <FlatUnravel<([String; 2], Vec<[String; 2]>), C> as Future<C>>::Ok

type Target = FlatUnravel<([String; 2], Vec<[String; 2]>), C>

impl<C: ?Sized + Write<<C as Dispatch<([String; 2], Vec<[String; 2]>)>>::Handle> + Fork<([String; 2], Vec<[String; 2]>)> + Unpin> Unravel<C> for Box<dyn Error + Send> where
    C::Future: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin
[src]

type Finalize = <FlatUnravel<([String; 2], Vec<[String; 2]>), C> as Future<C>>::Ok

type Target = FlatUnravel<([String; 2], Vec<[String; 2]>), C>

impl<C: ?Sized + Write<<C as Dispatch<([String; 2], Vec<[String; 2]>)>>::Handle> + Fork<([String; 2], Vec<[String; 2]>)> + Unpin> Unravel<C> for Box<dyn Error + Sync + Send> where
    C::Future: Unpin,
    C::Target: Unpin,
    C::Handle: Unpin,
    C::Finalize: Unpin
[src]

type Finalize = <FlatUnravel<([String; 2], Vec<[String; 2]>), C> as Future<C>>::Ok

type Target = FlatUnravel<([String; 2], Vec<[String; 2]>), C>

impl<'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce() -> U + 'a> where
    RefContextTarget<C>: Notify<()> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<()>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<()>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<()>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (), U, Box<dyn FnOnce() -> U + 'a>, fn(_: Box<dyn FnOnce() -> U + 'a>, _: ()) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<()>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<()>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<()>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0) -> U + 'a> where
    RefContextTarget<C>: Notify<(T0,)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0,)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0,)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0,)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0,), U, Box<dyn FnOnce(T0) -> U + 'a>, fn(_: Box<dyn FnOnce(T0) -> U + 'a>, _: (T0,)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0,)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0,)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0,)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1) -> U + 'a> where
    RefContextTarget<C>: Notify<(T0, T1)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1), U, Box<dyn FnOnce(T0, T1) -> U + 'a>, fn(_: Box<dyn FnOnce(T0, T1) -> U + 'a>, _: (T0, T1)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2) -> U + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2), U, Box<dyn FnOnce(T0, T1, T2) -> U + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2) -> U + 'a>, _: (T0, T1, T2)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3) -> U + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3), U, Box<dyn FnOnce(T0, T1, T2, T3) -> U + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3) -> U + 'a>, _: (T0, T1, T2, T3)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4) -> U + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4), U, Box<dyn FnOnce(T0, T1, T2, T3, T4) -> U + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4) -> U + 'a>, _: (T0, T1, T2, T3, T4)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5) -> U + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5) -> U + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5) -> U + 'a>, _: (T0, T1, T2, T3, T4, T5)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6) -> U + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6) -> U + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6) -> U + 'a>, _: (T0, T1, T2, T3, T4, T5, T6)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7) -> U + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7) -> U + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7) -> U + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, T15: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce() -> U + Sync + 'a> where
    RefContextTarget<C>: Notify<()> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<()>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<()>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<()>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (), U, Box<dyn FnOnce() -> U + Sync + 'a>, fn(_: Box<dyn FnOnce() -> U + Sync + 'a>, _: ()) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<()>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<()>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<()>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0) -> U + Sync + 'a> where
    RefContextTarget<C>: Notify<(T0,)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0,)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0,)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0,)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0,), U, Box<dyn FnOnce(T0) -> U + Sync + 'a>, fn(_: Box<dyn FnOnce(T0) -> U + Sync + 'a>, _: (T0,)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0,)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0,)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0,)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1) -> U + Sync + 'a> where
    RefContextTarget<C>: Notify<(T0, T1)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1), U, Box<dyn FnOnce(T0, T1) -> U + Sync + 'a>, fn(_: Box<dyn FnOnce(T0, T1) -> U + Sync + 'a>, _: (T0, T1)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2) -> U + Sync + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2), U, Box<dyn FnOnce(T0, T1, T2) -> U + Sync + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2) -> U + Sync + 'a>, _: (T0, T1, T2)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3) -> U + Sync + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3), U, Box<dyn FnOnce(T0, T1, T2, T3) -> U + Sync + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3) -> U + Sync + 'a>, _: (T0, T1, T2, T3)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4) -> U + Sync + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4), U, Box<dyn FnOnce(T0, T1, T2, T3, T4) -> U + Sync + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4) -> U + Sync + 'a>, _: (T0, T1, T2, T3, T4)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5) -> U + Sync + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5) -> U + Sync + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5) -> U + Sync + 'a>, _: (T0, T1, T2, T3, T4, T5)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6) -> U + Sync + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6) -> U + Sync + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6) -> U + Sync + 'a>, _: (T0, T1, T2, T3, T4, T5, T6)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7) -> U + Sync + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7) -> U + Sync + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7) -> U + Sync + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + Sync + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + Sync + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + Sync + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + Sync + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + Sync + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + Sync + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + Sync + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + Sync + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + Sync + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + Sync + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + Sync + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + Sync + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + Sync + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + Sync + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + Sync + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + Sync + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + Sync + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + Sync + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + Sync + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + Sync + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + Sync + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, T15: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + Sync + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + Sync + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + Sync + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce() -> U + Send + 'a> where
    RefContextTarget<C>: Notify<()> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<()>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<()>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<()>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (), U, Box<dyn FnOnce() -> U + Send + 'a>, fn(_: Box<dyn FnOnce() -> U + Send + 'a>, _: ()) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<()>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<()>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<()>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0) -> U + Send + 'a> where
    RefContextTarget<C>: Notify<(T0,)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0,)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0,)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0,)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0,), U, Box<dyn FnOnce(T0) -> U + Send + 'a>, fn(_: Box<dyn FnOnce(T0) -> U + Send + 'a>, _: (T0,)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0,)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0,)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0,)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1) -> U + Send + 'a> where
    RefContextTarget<C>: Notify<(T0, T1)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1), U, Box<dyn FnOnce(T0, T1) -> U + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1) -> U + Send + 'a>, _: (T0, T1)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2) -> U + Send + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2), U, Box<dyn FnOnce(T0, T1, T2) -> U + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2) -> U + Send + 'a>, _: (T0, T1, T2)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3) -> U + Send + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3), U, Box<dyn FnOnce(T0, T1, T2, T3) -> U + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3) -> U + Send + 'a>, _: (T0, T1, T2, T3)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4) -> U + Send + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4), U, Box<dyn FnOnce(T0, T1, T2, T3, T4) -> U + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4) -> U + Send + 'a>, _: (T0, T1, T2, T3, T4)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5) -> U + Send + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5) -> U + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5) -> U + Send + 'a>, _: (T0, T1, T2, T3, T4, T5)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6) -> U + Send + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6) -> U + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6) -> U + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7) -> U + Send + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7) -> U + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7) -> U + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + Send + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + Send + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + Send + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + Send + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + Send + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + Send + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + Send + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, T15: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + Send + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce() -> U + Sync + Send + 'a> where
    RefContextTarget<C>: Notify<()> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<()>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<()>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<()>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (), U, Box<dyn FnOnce() -> U + Sync + Send + 'a>, fn(_: Box<dyn FnOnce() -> U + Sync + Send + 'a>, _: ()) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<()>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<()>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<()>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: Notify<(T0,)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0,)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0,)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0,)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0,), U, Box<dyn FnOnce(T0) -> U + Sync + Send + 'a>, fn(_: Box<dyn FnOnce(T0) -> U + Sync + Send + 'a>, _: (T0,)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0,)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0,)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0,)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: Notify<(T0, T1)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1), U, Box<dyn FnOnce(T0, T1) -> U + Sync + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1) -> U + Sync + Send + 'a>, _: (T0, T1)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2), U, Box<dyn FnOnce(T0, T1, T2) -> U + Sync + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2) -> U + Sync + Send + 'a>, _: (T0, T1, T2)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3), U, Box<dyn FnOnce(T0, T1, T2, T3) -> U + Sync + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3) -> U + Sync + Send + 'a>, _: (T0, T1, T2, T3)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4), U, Box<dyn FnOnce(T0, T1, T2, T3, T4) -> U + Sync + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4) -> U + Sync + Send + 'a>, _: (T0, T1, T2, T3, T4)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5) -> U + Sync + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5) -> U + Sync + Send + 'a>, _: (T0, T1, T2, T3, T4, T5)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6) -> U + Sync + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6) -> U + Sync + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7) -> U + Sync + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7) -> U + Sync + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + Sync + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + Sync + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + Sync + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + Sync + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + Sync + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + Sync + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + Sync + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + Sync + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + Sync + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + Sync + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + Sync + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + Sync + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + Sync + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + Sync + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, T15: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> + Fork<U> + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch<U>>::Handle>,
    U: Unpin,
    <RefContextTarget<C> as Fork<U>>::Target: Unpin,
    <RefContextTarget<C> as Fork<U>>::Future: Unpin,
    <RefContextTarget<C> as Fork<U>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin
[src]

type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + Sync + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + Sync + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<C> as Fork<U>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<U>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut() -> U + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<()> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<()>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (), U, Self, fn(_: &mut Self, _: ()) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0) -> U + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0,)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0,), U, Self, fn(_: &mut Self, _: (T0,)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1) -> U + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1), U, Self, fn(_: &mut Self, _: (T0, T1)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2) -> U + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2), U, Self, fn(_: &mut Self, _: (T0, T1, T2)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3) -> U + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4) -> U + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5) -> U + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6) -> U + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7) -> U + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, T15: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn() -> U + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<()> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<()>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (), U, Self, fn(_: &mut Self, _: ()) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0) -> U + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0,)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0,), U, Self, fn(_: &mut Self, _: (T0,)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1) -> U + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1), U, Self, fn(_: &mut Self, _: (T0, T1)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2) -> U + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2), U, Self, fn(_: &mut Self, _: (T0, T1, T2)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3) -> U + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4) -> U + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5) -> U + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6) -> U + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7) -> U + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, T15: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut() -> U + Sync + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<()> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<()>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (), U, Self, fn(_: &mut Self, _: ()) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0) -> U + Sync + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0,)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0,), U, Self, fn(_: &mut Self, _: (T0,)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1) -> U + Sync + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1), U, Self, fn(_: &mut Self, _: (T0, T1)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2) -> U + Sync + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2), U, Self, fn(_: &mut Self, _: (T0, T1, T2)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3) -> U + Sync + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4) -> U + Sync + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5) -> U + Sync + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6) -> U + Sync + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7) -> U + Sync + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + Sync + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + Sync + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + Sync + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + Sync + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + Sync + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + Sync + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + Sync + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, T15: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + Sync + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn() -> U + Sync + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<()> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<()>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (), U, Self, fn(_: &mut Self, _: ()) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0) -> U + Sync + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0,)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0,), U, Self, fn(_: &mut Self, _: (T0,)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1) -> U + Sync + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1), U, Self, fn(_: &mut Self, _: (T0, T1)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2) -> U + Sync + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2), U, Self, fn(_: &mut Self, _: (T0, T1, T2)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3) -> U + Sync + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4) -> U + Sync + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5) -> U + Sync + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6) -> U + Sync + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7) -> U + Sync + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + Sync + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + Sync + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + Sync + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + Sync + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + Sync + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + Sync + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + Sync + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, T15: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + Sync + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut() -> U + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<()> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<()>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (), U, Self, fn(_: &mut Self, _: ()) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0) -> U + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0,)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0,), U, Self, fn(_: &mut Self, _: (T0,)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1) -> U + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1), U, Self, fn(_: &mut Self, _: (T0, T1)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2) -> U + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2), U, Self, fn(_: &mut Self, _: (T0, T1, T2)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3) -> U + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4) -> U + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5) -> U + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6) -> U + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7) -> U + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, T15: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn() -> U + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<()> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<()>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (), U, Self, fn(_: &mut Self, _: ()) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0) -> U + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0,)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0,), U, Self, fn(_: &mut Self, _: (T0,)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1) -> U + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1), U, Self, fn(_: &mut Self, _: (T0, T1)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2) -> U + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2), U, Self, fn(_: &mut Self, _: (T0, T1, T2)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3) -> U + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4) -> U + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5) -> U + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6) -> U + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7) -> U + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, T15: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut() -> U + Sync + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<()> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<()>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (), U, Self, fn(_: &mut Self, _: ()) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0,)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0,), U, Self, fn(_: &mut Self, _: (T0,)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1), U, Self, fn(_: &mut Self, _: (T0, T1)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2), U, Self, fn(_: &mut Self, _: (T0, T1, T2)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, T15: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn() -> U + Sync + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<()> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<()>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (), U, Self, fn(_: &mut Self, _: ()) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0,)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0,), U, Self, fn(_: &mut Self, _: (T0,)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1), U, Self, fn(_: &mut Self, _: (T0, T1)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2), U, Self, fn(_: &mut Self, _: (T0, T1, T2)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, T15: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + Sync + Send + 'a> where
    RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>,
    RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> + Fork<U> + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>,
    RefContextTarget<RefContextTarget<C>>: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize: Unpin,
    <RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future: Unpin,
    C::ForkOutput: Unpin,
    C: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin
[src]

type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) -> U>

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch<U>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork<U>>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

impl<'a, T, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Pin<Box<dyn Future<Output = T> + 'a>> where
    RefContextTarget<C>: Write<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, T>>>::Handle> + Notify<T>,
    T: Unpin,
    C::ForkOutput: Unpin,
    <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, T>>>::Finalize: Unpin,
    <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, T>>>::Future: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, T>>>::Target: Unpin,
    T: Unpin,
    <RefContextTarget<C> as Notify<T>>::Wrap: Unpin
[src]

type Finalize = ErasedFutureUnravel<Self, C>

type Target = MapErr<Fcr<C, ErasedFutureUnravel<Self, C>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedFutureUnravel<Self, C>>, fn(_: <Fcr<C, ErasedFutureUnravel<Self, C>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedFutureUnravel<Self, C>> as Future<C>>::Error) -> FutureUnravelError<<Fcr<C, ErasedFutureUnravel<Self, C>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedFutureUnravel<Self, C>> as Future<C>>::Error, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<Self::Output>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<Self::Output>>::Wrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<<RefContextTarget<C> as Notify<Self::Output>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<<RefContextTarget<C> as Notify<Self::Output>>::Notification>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<<RefContextTarget<C> as Notify<Self::Output>>::Notification>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Pin<Box<dyn Future<Output = T> + Sync + 'a>> where
    RefContextTarget<C>: Write<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, T>>>::Handle> + Notify<T>,
    T: Unpin,
    C::ForkOutput: Unpin,
    <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, T>>>::Finalize: Unpin,
    <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, T>>>::Future: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, T>>>::Target: Unpin,
    T: Unpin,
    <RefContextTarget<C> as Notify<T>>::Wrap: Unpin
[src]

type Finalize = ErasedFutureUnravel<Self, C>

type Target = MapErr<Fcr<C, ErasedFutureUnravel<Self, C>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedFutureUnravel<Self, C>>, fn(_: <Fcr<C, ErasedFutureUnravel<Self, C>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedFutureUnravel<Self, C>> as Future<C>>::Error) -> FutureUnravelError<<Fcr<C, ErasedFutureUnravel<Self, C>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedFutureUnravel<Self, C>> as Future<C>>::Error, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<Self::Output>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<Self::Output>>::Wrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<<RefContextTarget<C> as Notify<Self::Output>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<<RefContextTarget<C> as Notify<Self::Output>>::Notification>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<<RefContextTarget<C> as Notify<Self::Output>>::Notification>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Pin<Box<dyn Future<Output = T> + Send + 'a>> where
    RefContextTarget<C>: Write<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, T>>>::Handle> + Notify<T>,
    T: Unpin,
    C::ForkOutput: Unpin,
    <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, T>>>::Finalize: Unpin,
    <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, T>>>::Future: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, T>>>::Target: Unpin,
    T: Unpin,
    <RefContextTarget<C> as Notify<T>>::Wrap: Unpin
[src]

type Finalize = ErasedFutureUnravel<Self, C>

type Target = MapErr<Fcr<C, ErasedFutureUnravel<Self, C>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedFutureUnravel<Self, C>>, fn(_: <Fcr<C, ErasedFutureUnravel<Self, C>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedFutureUnravel<Self, C>> as Future<C>>::Error) -> FutureUnravelError<<Fcr<C, ErasedFutureUnravel<Self, C>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedFutureUnravel<Self, C>> as Future<C>>::Error, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<Self::Output>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<Self::Output>>::Wrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<<RefContextTarget<C> as Notify<Self::Output>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<<RefContextTarget<C> as Notify<Self::Output>>::Notification>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<<RefContextTarget<C> as Notify<Self::Output>>::Notification>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, T, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Pin<Box<dyn Future<Output = T> + Sync + Send + 'a>> where
    RefContextTarget<C>: Write<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, T>>>::Handle> + Notify<T>,
    T: Unpin,
    C::ForkOutput: Unpin,
    <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, T>>>::Finalize: Unpin,
    <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, T>>>::Future: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, T>>>::Target: Unpin,
    T: Unpin,
    <RefContextTarget<C> as Notify<T>>::Wrap: Unpin
[src]

type Finalize = ErasedFutureUnravel<Self, C>

type Target = MapErr<Fcr<C, ErasedFutureUnravel<Self, C>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedFutureUnravel<Self, C>>, fn(_: <Fcr<C, ErasedFutureUnravel<Self, C>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedFutureUnravel<Self, C>> as Future<C>>::Error) -> FutureUnravelError<<Fcr<C, ErasedFutureUnravel<Self, C>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedFutureUnravel<Self, C>> as Future<C>>::Error, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<Self::Output>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<Self::Output>>::Wrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<<RefContextTarget<C> as Notify<Self::Output>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<<RefContextTarget<C> as Notify<Self::Output>>::Notification>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<<RefContextTarget<C> as Notify<Self::Output>>::Notification>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Pin<Box<dyn Stream<Item = U> + 'a>> where
    RefContextTarget<C>: Notify<()> + Notify<U> + Read<Option<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, ()>>>::Handle>> + Write<Option<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, U>>>::Handle>>,
    U: Unpin,
    C: Unpin,
    C::ForkOutput: Unpin,
    <RefContextTarget<C> as Notify<U>>::Wrap: Unpin,
    <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, U>>>::Target: Unpin,
    <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, U>>>::Future: Unpin,
    <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, U>>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<()>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<Notification<RefContextTarget<C>, ()>>>::Future: Unpin
[src]

type Finalize = ErasedStreamUnravel<C, Self>

type Target = MapErr<Fcr<C, ErasedStreamUnravel<C, Self>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedStreamUnravel<C, Self>>, fn(_: <Fcr<C, ErasedStreamUnravel<C, Self>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedStreamUnravel<C, Self>> as Future<C>>::Error) -> StreamUnravelError<<RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, ()>>>::Handle>>>::Error, <<RefContextTarget<C> as Notify<()>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<Notification<RefContextTarget<C>, ()>>>::Future as Future<RefContextTarget<C>>>::Error, <Fcr<C, ErasedStreamUnravel<C, Self>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedStreamUnravel<C, Self>> as Future<C>>::Error, <RefContextTarget<C> as Write<Option<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, Self::Item>>>::Handle>>>::Error, <<RefContextTarget<C> as Notify<Self::Item>>::Wrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, Self::Item>>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, Self::Item>>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, Self::Item>>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Pin<Box<dyn Stream<Item = U> + Sync + 'a>> where
    RefContextTarget<C>: Notify<()> + Notify<U> + Read<Option<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, ()>>>::Handle>> + Write<Option<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, U>>>::Handle>>,
    U: Unpin,
    C: Unpin,
    C::ForkOutput: Unpin,
    <RefContextTarget<C> as Notify<U>>::Wrap: Unpin,
    <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, U>>>::Target: Unpin,
    <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, U>>>::Future: Unpin,
    <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, U>>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<()>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<Notification<RefContextTarget<C>, ()>>>::Future: Unpin
[src]

type Finalize = ErasedStreamUnravel<C, Self>

type Target = MapErr<Fcr<C, ErasedStreamUnravel<C, Self>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedStreamUnravel<C, Self>>, fn(_: <Fcr<C, ErasedStreamUnravel<C, Self>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedStreamUnravel<C, Self>> as Future<C>>::Error) -> StreamUnravelError<<RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, ()>>>::Handle>>>::Error, <<RefContextTarget<C> as Notify<()>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<Notification<RefContextTarget<C>, ()>>>::Future as Future<RefContextTarget<C>>>::Error, <Fcr<C, ErasedStreamUnravel<C, Self>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedStreamUnravel<C, Self>> as Future<C>>::Error, <RefContextTarget<C> as Write<Option<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, Self::Item>>>::Handle>>>::Error, <<RefContextTarget<C> as Notify<Self::Item>>::Wrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, Self::Item>>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, Self::Item>>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, Self::Item>>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Pin<Box<dyn Stream<Item = U> + Send + 'a>> where
    RefContextTarget<C>: Notify<()> + Notify<U> + Read<Option<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, ()>>>::Handle>> + Write<Option<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, U>>>::Handle>>,
    U: Unpin,
    C: Unpin,
    C::ForkOutput: Unpin,
    <RefContextTarget<C> as Notify<U>>::Wrap: Unpin,
    <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, U>>>::Target: Unpin,
    <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, U>>>::Future: Unpin,
    <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, U>>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<()>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<Notification<RefContextTarget<C>, ()>>>::Future: Unpin
[src]

type Finalize = ErasedStreamUnravel<C, Self>

type Target = MapErr<Fcr<C, ErasedStreamUnravel<C, Self>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedStreamUnravel<C, Self>>, fn(_: <Fcr<C, ErasedStreamUnravel<C, Self>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedStreamUnravel<C, Self>> as Future<C>>::Error) -> StreamUnravelError<<RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, ()>>>::Handle>>>::Error, <<RefContextTarget<C> as Notify<()>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<Notification<RefContextTarget<C>, ()>>>::Future as Future<RefContextTarget<C>>>::Error, <Fcr<C, ErasedStreamUnravel<C, Self>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedStreamUnravel<C, Self>> as Future<C>>::Error, <RefContextTarget<C> as Write<Option<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, Self::Item>>>::Handle>>>::Error, <<RefContextTarget<C> as Notify<Self::Item>>::Wrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, Self::Item>>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, Self::Item>>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, Self::Item>>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Pin<Box<dyn Stream<Item = U> + Sync + Send + 'a>> where
    RefContextTarget<C>: Notify<()> + Notify<U> + Read<Option<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, ()>>>::Handle>> + Write<Option<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, U>>>::Handle>>,
    U: Unpin,
    C: Unpin,
    C::ForkOutput: Unpin,
    <RefContextTarget<C> as Notify<U>>::Wrap: Unpin,
    <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, U>>>::Target: Unpin,
    <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, U>>>::Future: Unpin,
    <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, U>>>::Finalize: Unpin,
    RefContextTarget<C>: Unpin,
    <RefContextTarget<C> as Notify<()>>::Unwrap: Unpin,
    <RefContextTarget<C> as Join<Notification<RefContextTarget<C>, ()>>>::Future: Unpin
[src]

type Finalize = ErasedStreamUnravel<C, Self>

type Target = MapErr<Fcr<C, ErasedStreamUnravel<C, Self>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedStreamUnravel<C, Self>>, fn(_: <Fcr<C, ErasedStreamUnravel<C, Self>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedStreamUnravel<C, Self>> as Future<C>>::Error) -> StreamUnravelError<<RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, ()>>>::Handle>>>::Error, <<RefContextTarget<C> as Notify<()>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<Notification<RefContextTarget<C>, ()>>>::Future as Future<RefContextTarget<C>>>::Error, <Fcr<C, ErasedStreamUnravel<C, Self>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedStreamUnravel<C, Self>> as Future<C>>::Error, <RefContextTarget<C> as Write<Option<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, Self::Item>>>::Handle>>>::Error, <<RefContextTarget<C> as Notify<Self::Item>>::Wrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, Self::Item>>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, Self::Item>>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, Self::Item>>>::Finalize as Future<RefContextTarget<C>>>::Error>>

impl<T, C: ?Sized + Write<Vec<<C as Dispatch<T>>::Handle>> + Fork<T> + Unpin> Unravel<C> for Vec<T> where
    T: Unpin,
    C::Handle: Unpin,
    C::Future: Unpin,
    C::Finalize: Unpin,
    C::Target: Unpin
[src]

type Finalize = MapErr<VecFinalize<C, T>, fn(_: <VecFinalize<C, T> as Future<C>>::Error) -> VecUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = VecUnravel<Rev<IntoIter<T>>, C>

Loading content...

Implementors

impl<C: ?Sized> Unravel<C> for ProtocolError where
    Box<dyn Error + Send>: Unravel<C>, 
[src]

type Finalize = <Box<dyn Error + Send> as Unravel<C>>::Finalize

type Target = <Box<dyn Error + Send> as Unravel<C>>::Target

Loading content...